use nacos_client::{NacosClient, NacosClientConfig};
use std::sync::Arc;
use tokio;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🦀 Rust Nacos集群客户端测试");
    println!("=".repeat(50));
    
    // 创建两个不同的客户端，连接不同节点
    let client1 = NacosClient::new(NacosClientConfig::builder()
        .server_addr("127.0.0.1:8848")
        .namespace("public")
        .cluster_nodes(vec![
            "127.0.0.1:8848".to_string(),
            "127.0.0.1:8849".to_string(),
            "127.0.0.1:8850".to_string(),
            "127.0.0.1:8851".to_string(),
        ])
        .build()?)?;

    let client2 = NacosClient::new(NacosClientConfig::builder()
        .server_addr("127.0.0.1:8849") // 连接不同节点
        .namespace("public")
        .cluster_nodes(vec![
            "127.0.0.1:8848".to_string(),
            "127.0.0.1:8849".to_string(),
            "127.0.0.1:8850".to_string(),
            "127.0.0.1:8851".to_string(),
        ])
        .build()?)?
    ;

    println!("🎯 客户端1连接节点1 (127.0.0.1:8848)");
    println!("🎯 客户端2连接节点2 (127.0.0.1:8849)");
    
    // 测试1: 客户端1注册服务
    println!("\n🧪 测试1: 客户端1注册服务");
    client1.register_instance(
        "rust-service-1",
        "127.0.0.1",
        8081,
        std::collections::HashMap::new(),
    ).await?;
    println!("✅ 客户端1注册rust-service-1成功");

    // 测试2: 客户端2注册服务
    println!("\n🧪 测试2: 客户端2注册服务");
    client2.register_instance(
        "rust-service-2",
        "127.0.0.1",
        8082,
        std::collections::HashMap::new(),
    ).await?;
    println!("✅ 客户端2注册rust-service-2成功");

    // 测试3: 检查集群发现
    println!("\n🧪 测试3: 检查集群节点发现");
    tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;

    // 客户端1查看所有服务
    let services1 = client1.get_all_instances("rust-service-1").await?;
    let services2 = client2.get_all_instances("rust-service-2").await?;
    
    println!("📊 客户端1发现的服务实例:");
    for instance in &services1 {
        println!("   🏷️  {}:{} ({})", instance.ip, instance.port, instance.service_name);
    }

    println!("📊 客户端2发现的服务实例:");
    for instance in &services2 {
        println!("   🏷️  {}:{} ({})", instance.ip, instance.port, instance.service_name);
    }

    // 测试4: 配置共享
    println!("\n🧪 测试4: 配置共享测试");
    client1.publish_config(
        "shared-config",
        "DEFAULT_GROUP",
        "shared-by-client1",
    ).await?;
    println!("✅ 客户端1发布共享配置");

    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;

    let config = client2.get_config("shared-config", "DEFAULT_GROUP").await?;
    println!("📝 客户端2获取共享配置: {}", config.unwrap_or("未找到".to_string()));

    // 测试5: 故障转移测试
    println!("\n🧪 测试5: 故障转移测试");
    println!("⚠️  请手动停止一个节点，然后按回车继续...");
    
    // 等待用户操作
    let mut input = String::new();
    std::io::stdin().read_line(&mut input).unwrap();

    // 测试故障转移后的功能
    match client1.register_instance(
        "test-after-failover",
        "127.0.0.1",
        8083,
        std::collections::HashMap::new(),
    ).await {
        Ok(_) => println!("✅ 故障转移后注册成功 - 集群正常工作"),
        Err(e) => println!("❌ 故障转移后注册失败: {}", e),
    }

    println!("\n🎯 集群测试完成！");
    
    // 清理测试数据
    client1.deregister_instance("rust-service-1", "127.0.0.1", 8081).await.ok();
    client2.deregister_instance("rust-service-2", "127.0.0.1", 8082).await.ok();
    client1.deregister_instance("test-after-failover", "127.0.0.1", 8083).await.ok();
    client1.remove_config("shared-config", "DEFAULT_GROUP").await.ok();

    Ok(())
}